package com.hui.qiniucloud.service.impl;

import com.hui.qiniucloud.entity.AICharacter;
import com.hui.qiniucloud.entity.Result;
import com.hui.qiniucloud.mapper.CharacterMapper;
import com.hui.qiniucloud.service.ICharacterService;
import com.hui.qiniucloud.service.ImageService;
import jakarta.annotation.PostConstruct;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import org.springframework.web.multipart.MultipartFile;

import java.util.List;

@Service
public class CharacterService implements ICharacterService {

    @Autowired
    private CharacterMapper characterMapper;

    @Autowired
    @Qualifier("imageImpl")
    private ImageService iImagesService;


    @PostConstruct
    public void initializeDefaultCharacters() {
        List<AICharacter> existingCharacters = characterMapper.selectAllActive();
        if (existingCharacters.isEmpty()) {
            insertDefaultCharacters();
        }
    }



    public Result uploadImage(MultipartFile mpFile) {
        String url = iImagesService.uploadImage(mpFile,"images");
        return Result.success(url);

    }
    private void insertDefaultCharacters() {
        // 哈利波特
        insertCharacterIfNotExists(new AICharacter(
            "harry_potter",
            "哈利·波特",
            "霍格沃茨魔法学校的学生，拥有闪电形伤疤的男巫",
            "你是哈利·波特，霍格沃茨魔法学校格兰芬多学院的学生。你勇敢、正直，有着强烈的正义感。你经历过与伏地魔的多次对抗，拥有丰富的魔法知识和冒险经历。在对话中，你会经常提到魔法、霍格沃茨、朋友罗恩和赫敏，以及你的冒险经历。",
            "勇敢、忠诚、有时冲动但内心善良",
            "孤儿出身，在德思礼家长大，11岁时发现自己是巫师，进入霍格沃茨学习魔法",
            "BV001_streaming"
        ));

        // 赫敏·格兰杰
        insertCharacterIfNotExists(new AICharacter(
            "hermione",
            "赫敏·格兰杰",
            "聪明好学的小女巫，哈利·波特的好朋友",
            "你是赫敏·格兰杰，哈利·波特和罗恩·韦斯莱的好朋友。你聪明、好学，对魔法理论有深入的理解。你总是认真对待学习，经常在图书馆研究，并且乐于帮助朋友解决问题。你说话时会展现出广博的知识和逻辑性的思维。",
            "聪明、认真、有时完美主义，但忠诚可靠",
            "麻瓜出身，通过努力学习成为霍格沃茨最优秀的学生之一",
            "BV002_streaming"
        ));

        // 苏格拉底
        insertCharacterIfNotExists(new AICharacter(
            "socrates",
            "苏格拉底",
            "古希腊哲学家，以苏格拉底方法闻名",
            "你是苏格拉底，古希腊的哲学家。你相信'未经审视的生活不值得过'，喜欢通过提问的方式引导他人思考。你会用反问和对话的方式来探索真理，而不是直接给出答案。你谦逊地认为自己'只知道自己无知'。",
            "智慧、谦逊、善于提问和思辨",
            "古希腊雅典的哲学家，致力于道德哲学和认识论的研究",
            "BV003_streaming"
        ));

        // 爱因斯坦
        insertCharacterIfNotExists(new AICharacter(
            "einstein",
            "阿尔伯特·爱因斯坦",
            "著名物理学家，相对论的提出者",
            "你是阿尔伯特·爱因斯坦，20世纪最伟大的物理学家之一。你提出了相对论，对现代物理学产生了深远影响。你善于用简单的语言解释复杂的科学概念，具有深刻的人文关怀和对和平的向往。",
            "好奇、富有想象力、深度思考者",
            "德裔理论物理学家，诺贝尔物理学奖获得者",
            "BV004_streaming"
        ));

        // 林黛玉
        insertCharacterIfNotExists(new AICharacter(
            "lin_daiyu",
            "林黛玉",
            "《红楼梦》中的才女，贾宝玉的表妹",
            "你是林黛玉，《红楼梦》中的女主角。你才华横溢，诗词歌赋样样精通，但性格敏感多疑，经常因小事而伤心。你与贾宝玉青梅竹马，情深意重。说话时要体现古代女子的文雅和诗意。",
            "才华出众但敏感多愁，心思细腻",
            "荣国府贾母的外孙女，父母双亡后寄居贾府",
            "BV005_streaming"
        ));

        // 孔子
        insertCharacterIfNotExists(new AICharacter(
            "confucius",
            "孔子",
            "中国古代伟大的思想家、教育家",
            "你是孔子，中国古代的圣人，儒家学派的创始人。你提倡'仁爱'思想，重视教育和道德修养。你说话文雅，经常引用经典，喜欢用比喻来阐述道理。",
            "仁慈、智慧、重视教育和道德",
            "春秋时期鲁国人，周游列国传播思想",
            "BV006_streaming"
        ));
    }

    private void insertCharacterIfNotExists(AICharacter character) {
        AICharacter existing = characterMapper.selectActiveById(character.getId());
        if (existing == null) {
            characterMapper.insert(character);
        }
    }

    public List<AICharacter> getAllCharacters() {
        return characterMapper.selectAllActive();
    }

    public AICharacter getCharacterById(String characterId) {
        if (!StringUtils.hasText(characterId)) {
            return null;
        }
        return characterMapper.selectActiveById(characterId);
    }

    public void addCharacter(AICharacter character) {
        if (character != null && StringUtils.hasText(character.getId())) {
            characterMapper.insert(character);
        }
    }

    public void updateCharacter(AICharacter character) {
        if (character != null && StringUtils.hasText(character.getId())) {
            AICharacter existing = characterMapper.selectActiveById(character.getId());
            if (existing != null) {
                characterMapper.updateById(character);
            }
        }
    }

    public void deleteCharacter(String characterId) {
        if (StringUtils.hasText(characterId)) {
            AICharacter character = characterMapper.selectActiveById(characterId);
            if (character != null) {
                characterMapper.deleteById(characterId);
            }
        }
    }

    public List<AICharacter> searchCharacters(String keyword) {
        if (!StringUtils.hasText(keyword)) {
            return getAllCharacters();
        }
        return characterMapper.searchByKeyword(keyword);
    }


    /**
     * 根据用户ID获取角色列表
     * @param userId 用户ID
     * @return 角色列表
     */
    public List<AICharacter> getUserCharacters(Long userId) {
        return characterMapper.selectByUserId(userId);
    }

    /**
     * 获取系统预设角色
     * @return 系统角色列表
     */
    public List<AICharacter> getSystemCharacters() {
        return characterMapper.selectSystemCharacters();
    }

    /**
     * 根据用户ID搜索角色
     * @param userId 用户ID
     * @param keyword 关键词
     * @return 角色列表
     */
    public List<AICharacter> searchUserCharacters(Long userId, String keyword) {
        if (keyword != null && !keyword.trim().isEmpty()) {
            return characterMapper.searchByUserIdAndKeyword(userId, keyword);
        } else {
            return characterMapper.selectByUserId(userId);
        }
    }

    /**
     * 创建用户角色
     * @param character 角色信息
     * @param userId 用户ID
     * @return 结果
     */
    public Result<AICharacter> createUserCharacter(AICharacter character, Long userId) {
        if (character == null) {
            return Result.fail("请填写角色信息");
        }

        // 设置用户ID，表示这是用户创建的角色
        character.setUserId(userId);

        int insert = characterMapper.insert(character);
        if (insert <= 0) {
            return Result.fail("创建角色失败");
        }
        return Result.success(character);
    }

    /**
     * 更新用户角色（只能更新自己的角色）
     * @param character 角色信息
     * @param userId 用户ID
     * @return 结果
     */
    public Result<AICharacter> updateUserCharacter(AICharacter character, Long userId) {
        if (character == null) {
            return Result.fail("请填写角色信息");
        }

        // 检查角色是否存在且属于该用户
        AICharacter existingCharacter = characterMapper.selectActiveById(character.getId());
        if (existingCharacter == null) {
            return Result.fail("角色不存在");
        }

        // 检查是否为系统角色（user_id为null的不允许普通用户修改）
        if (existingCharacter.getUserId() == null) {
            return Result.fail("系统预设角色不允许修改");
        }

        // 检查是否为当前用户的角色
        if (!existingCharacter.getUserId().equals(userId)) {
            return Result.fail("只能修改自己创建的角色");
        }

        // 保持用户ID不变
        character.setUserId(userId);

        int update = characterMapper.updateById(character);
        if (update <= 0) {
            return Result.fail("更新角色失败");
        }
        return Result.success(character);
    }

    /**
     * 删除用户角色（只能删除自己的角色）
     * @param characterId 角色ID
     * @param userId 用户ID
     * @return 结果
     */
    public Result<String> deleteUserCharacter(String characterId, Long userId) {
        if (!StringUtils.hasText(characterId)) {
            return Result.fail("角色ID不能为空");
        }

        AICharacter character = characterMapper.selectActiveById(characterId);
        if (character == null) {
            return Result.fail("角色不存在");
        }

        // 检查是否为系统角色
        if (character.getUserId() == null) {
            return Result.fail("系统预设角色不允许删除");
        }

        // 检查是否为当前用户的角色
        if (!character.getUserId().equals(userId)) {
            return Result.fail("只能删除自己创建的角色");
        }

        int delete = characterMapper.deleteById(characterId);
        if (delete <= 0) {
            return Result.fail("删除角色失败");
        }
        return Result.success();
    }

    public Result<AICharacter> create(AICharacter aiCharacter) {
        if (aiCharacter == null) {
            return Result.fail("请填写角色信息");
        }
        int insert = characterMapper.insert(aiCharacter);
        if (insert <= 0) {
            return Result.fail("创建角色失败");
        }
        return Result.success(aiCharacter);
    }

    public Result<AICharacter> update(AICharacter aiCharacter) {
        if (aiCharacter == null) {
            return Result.fail("请填写角色信息");
        }
        int update = characterMapper.updateById(aiCharacter);
        if (update <= 0) {
            return Result.fail("更新角色失败");
        }
        return Result.success(aiCharacter);
    }

    public Result<String> delete(String characterId) {
        if (!StringUtils.hasText(characterId)) {
            return Result.fail("角色ID不能为空");
        }
        int delete = characterMapper.deleteById(characterId);
        if (delete <= 0) {
            return Result.fail("删除角色失败");
        }
        return Result.success();
    }
}